Decision.c

Go to the documentation of this file.

#include "derivative.h"
#include "Compile_Options.h"
#include "Decision.h"
#include "SM.h"
#include "SBC_AL.h"
#include "HAL.h"
#include "MailScheduler.h"
#include "Application_Globals.h"
#include "SIU.h"
/*
 ******************************************************************************
 * Constants
 ******************************************************************************
 */
const uint16_t cau16PreDecisionValidStates[] =
{
  SM_STATE_ERROR, SM_APPLICATION_START };
/*
 ******************************************************************************
 * Globals
 ******************************************************************************
 */
/*
 ******************************************************************************
 * u32fnStateDecision
 ******************************************************************************
 */
uint32_t u32fnStateDecision(void)
{
  uint32_t u32Status;
  
  
  /* Verify that we can execute - Previous state ended correctly */
  u32Status
      = u32fnSMValidateCurrentState((uint16_t*)cau16PreDecisionValidStates,
                                    N_ELEMENTS(cau16PreDecisionValidStates));
  if(CLEAR == u32Status)
  {
    /* Here comes the real contents of the state */
    LOCK_STATE_EXECUTION();
    
    /* Run the algorithm */
    u32Status = u32fnDecisionMath(gu16ActivePSI5Channels, 
                                  (uint16_t*)&gau16RawAccels[SM_PSI5_GLOBAL_INDEX],
                                  (uint16_t*)&gu16CrashedSatellites);
    if(CLEAR == u32Status)
    {
      /* Run  the Safing */
      u32Status = u32fnDecisionSafing(gu16CrashedSatellites,
                                (uint16_t*)&gau16RawAccels[SM_CA_GLOBAL_INDEX],
                                (uint16_t*)&gu16ConfirmedSatellites);
      
      /* Result from operation above will flag confirmed satellites only;    */
      /* meaning that if the error flag is set, it is due to an unconfirmed  */
      /* satellite. Therefore, we must treat this error accordingly, but we  */
      /* shall also decide which squibs are going to be triggered. Therefore */
      /* the next step does not require an empty u32Status, but it will      */
      /* remember the previous one and report it.                            */
      u32Status |= u32fnDecisionSelection(gu16ConfirmedSatellites,
                                          gu16ActiveSquibChannels,
                                          (uint16_t*)&gu16SquibsToFire);
    }
    else
    {
      /* Leave with error code */
    }
    /* Unlock the state */
    UNLOCK_STATE_EXECUTION();
  }
  else
  {
    /* Leave */
  }

  /* Set the next state */
  if(CLEAR == u32Status)
  {
    vfnSMWriteNextState(SM_STATE_DEPLOYMENT);
  }
  else
  {
    vfnSMWriteNextState(SM_STATE_ERROR);
  }
  return (u32Status);
}
/*
 ******************************************************************************
 * u32fnDecisionMath
 ******************************************************************************
 */
static uint32_t u32fnDecisionMath(const uint16_t cu16PSI5Channels, 
                                  const uint16_t* pu16Acceleration, 
                                  uint16_t* pu16SatelliteSensedCrash)
{
  uint32_t u32Status;
  uint8_t u8Index;
  uint16_t u16ChannelMask;
  
  u32Status = CLEAR;
  u8Index = CLEAR;
  
  /* Below is a sample application where satellite sensors are compared   */
  /* against a threshold; if the threshold is passed, we assume there has */
  /* been an impact detected by the sensor. Real world application should */
  /* replace this threshold detection since it is not tested in any kind  */
  /* of environment other than a lab with an evaluation board and is not  */
  /* representative of a complete solution.                               */
  *pu16SatelliteSensedCrash = CLEAR;
  for(u16ChannelMask = BIT0; u16ChannelMask < BIT12; u16ChannelMask <<= 1u)
  {
    if(u16ChannelMask & cu16PSI5Channels)
    {
      /* If the channel is active, check the acceleration vs. the threshold */
      *pu16SatelliteSensedCrash |=  
          (*(pu16Acceleration + u8Index) > cau16PSI5CrashThresholds[u8Index]) 
           << u8Index;
    }
    else
    {
      /* Not going to perform a test against this */
    }
    u8Index++;
  }
  return(u32Status);
}
/*
 ******************************************************************************
 * u32fnDecisionSafing
 ******************************************************************************
 */
static uint32_t u32fnDecisionSafing(const uint16_t cu16CrashedSatellites, 
                                    const uint16_t* pu16CAAccel,
                                    uint16_t* pu16ConfirmedSatellites)
{
  uint32_t u32Status;
  uint8_t  au8CAShock[2u];
  uint8_t u8Index;
  uint16_t u16ChannelMask;
  
  /* Init variables */
  u8Index = CLEAR;
  *pu16ConfirmedSatellites = CLEAR;
  u32Status = CLEAR;
  
  /* We will now consult our central accelerometer with regards to the crash */
  /* A "1" will be set if there has been a crash, "0" otherwise.             */
  au8CAShock[CA_CRASH_X] = (*pu16CAAccel > cau16CACrashThresholds[CA_CRASH_X]);
  au8CAShock[CA_CRASH_Y] = (*(pu16CAAccel + 1u) > 
                               cau16CACrashThresholds[CA_CRASH_Y]);
  
  /* Next, we will go through all satellites */
  for(u16ChannelMask = BIT0; u16ChannelMask < BIT12; u16ChannelMask <<= 1u)
  {
    if(cu16CrashedSatellites & u16ChannelMask)
    {
      /* This satellite has detected a crash condition. Check it against */
      /* it's safing axis which is correlated through a special table    */
      if(TRUE == au8CAShock[cau8SatelliteDetectionDirection[u8Index]])
      {
        /* CA has detected a shock in the pertinent direction */
        /* we agree with it, therefore we can continue checking DIS_ALP and DIS_AHP*/
        if((CLEAR == u8fnReadPin(PIN_DIS_ALP)) && (CLEAR == u8fnReadPin(PIN_DIS_AHP)))
        {
          /* Add to the list of confirmed satellites */
          *pu16ConfirmedSatellites |= u16ChannelMask;
        }/* end if safing is confirmed */
        else
        {
          /* Safing has not been confirmed. We need to flag this in the */
          /* status word                                                */
          u32Status |= DECISION_ERROR_SAFING_PIN;
        } /* end else (safing is not confirmed) */
      } /* end if CA confirms acceleration axis */
      else
      {
        /* The accelerometer did not agree with the satellite. */
        /* This is not an error, just a working condition. */
        /* We will not flag it */
        /* u32Status |= CLEAR; */
      } /* end else (CA does not confirm acceleration axis) */
    } /* end if satellite has been detected as crashed */
    else
    {
      /* This satellite has not been crashed */
    }
    u8Index++;
  }
  return(u32Status);
}
/*
 ******************************************************************************
 * u32fnDecisionSelection
 ******************************************************************************
 */
static uint32_t u32fnDecisionSelection(const uint16_t cu16ConfirmedSatellites,
                                       const uint16_t cu16ActiveSquibs,
                                       uint16_t* pu16SquibsToFire)
{
  uint32_t u32Status;
  uint8_t u8Index1;
  uint8_t u8Index2;
  uint16_t u16ChannelMask;
  
  u32Status = CLEAR;
  
  /* Index1 will tell us which satellite we're referring to */
  u8Index1 = CLEAR;
  
  /* Forget any previous firing values */
  *pu16SquibsToFire = CLEAR;
  
  for(u16ChannelMask = BIT0; u16ChannelMask < BIT12; u16ChannelMask <<= 1u)
  {
    if(u16ChannelMask & cu16ConfirmedSatellites)
    {
      /* If this is a confirmed satellite, we need to fire all squibs    */
      /* related to it Index2 keeps record of where in the relationship  */
      /* table between satellites and squibs we are.                     */
      for(u8Index2 = CLEAR; u8Index2 < cu8SizeOfSatToSquibs; u8Index2 += 2u)
      {
        /* We will search the whole table */
        if(cau8SatToSquibs[u8Index2] == u8Index1)
        {
          /* And if there's a match, we will verify that this is an active */
          /* squib - we never want to enable an inactive squib.            */
          if(cu16ActiveSquibs & (BIT0 << cau8SatToSquibs[(u8Index2 + 1u)]))
          {
            /* If this is the satellite in question, enable the squib if */
            *pu16SquibsToFire |= (BIT0 << cau8SatToSquibs[(u8Index2 + 1u)]);
          }
          else
          {
            /* This is an inactive squib, we can't do anything about it */
          }
        }
        else
        {
          /* There's nothing to do */
        } 
      } /* End for */ 
    } /* end if squib is active */
    else
    {
      /* Don't fire anything */
    } /* end else (squib is not active) */
    u8Index1++;
  }/* end for */
  
  return(u32Status);
}
/*
 ******************************************************************************
 *
 *  End of file.
 *
 ******************************************************************************
 */